package com.iaz.tech.tools.tasks.schedule;

import lombok.Data;
import lombok.EqualsAndHashCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.iaz.tech.tools.common.utils.UtilTools;
 
/**
 * 循环计划实现类
 * 支持按照指定次数或时间间隔循环执行任务
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class CyclicPlan extends ScheduleItem {
    
    /**
     * 日志
     */
    private final static Logger logger = LoggerFactory.getLogger(CyclicPlan.class);
    
    /**
     * 计划名称
     */
    private String planName;
    
    /**
     * 循环执行次数，-1表示无限循环
     */
    private long cycleCount = -1;
    
    /**
     * 当前已执行次数
     */
    private long currentCycle = -1;
    
    /**
     * 每次循环间隔时间（毫秒）
     */
    private long intervalMs = 1000;
    
    /**
     * 是否正在执行中
     */
    private volatile boolean running = false;

    private long startTime = -1;
    
    /**
     * 构造方法
     */
    public CyclicPlan() {
        super();
        this.planName = "CyclicPlan_" + this.getScheduleID();
    }
    
    /**
     * 构造方法，指定计划名称和循环次数
     * @param planName 计划名称
     * @param cycleCount 循环次数，-1表示无限循环
     */
    public CyclicPlan(String planName, long cycleCount) {
        super();
        this.planName = planName;
        this.cycleCount = cycleCount;
    }
    
    /**
     * 构造方法，指定所有参数
     * @param planName 计划名称
     * @param cycleCount 循环次数，-1表示无限循环
     * @param intervalMs 循环间隔时间（毫秒）
     */
    public CyclicPlan(String planName, long cycleCount, long intervalMs) {
        super();
        this.planName = planName;
        this.cycleCount = cycleCount;
        this.intervalMs = intervalMs;
    }
    /**
     * 获取当前循环进度
     * @return 循环进度百分比
     */
    public double getProgressPercentage() {
        if (cycleCount <= 0) {
            return 0; // 无限循环或无效循环次数
        }
        return ((double) currentCycle / cycleCount) * 100;
    }

    /**
     * 满足执行计划，根据计划开始时间和结束时间，以及Cycle 时间进行处理
     * @return
     */
    @Override
    public Boolean confirm() {
        boolean result = false;
        try {
            long current_time = UtilTools.getCurrentTime();
            if ((this.getPlanStartTime() != -1) && (current_time < this.getPlanStartTime())){
                return result;
            }

            if ((this.getPlanEndTime() != -1) && (current_time > this.getPlanEndTime())){
                return result;
            }

            if (this.cycleCount != -1 ){
                if (this.currentCycle >= this.cycleCount){
                    return result;
                }
            }

            if (this.intervalMs != -1 ){
                if (this.startTime > 0){
                   long last_time = this.startTime; 
                    if (current_time < last_time + this.intervalMs){
                        return result;
                    } 
                }
            }
            result = true;
        } catch( Exception e) {
            logger.error("执行confirm出现错误：" + e.getMessage());
        }
        return result;
    }
}